home *** CD-ROM | disk | FTP | other *** search
/ Power Hacker 2003 / Power_Hacker_2003.iso / Exploit and vulnerability / w00w00 / sectools / dsniff / decode.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-17  |  4.3 KB  |  193 lines
  1. /*
  2.   decode.c
  3.  
  4.   Copyright (c) 2000 Dug Song <dugsong@monkey.org>
  5.   
  6.   $Id: decode.c,v 1.5 2000/05/17 08:12:55 dugsong Exp $
  7. */
  8.  
  9. #include <sys/types.h>
  10. #include <arpa/telnet.h>
  11. #include <rpc/rpc.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include <ctype.h>
  15. #include "decode.h"
  16.  
  17. extern int decode_hex(u_char *, int);
  18. extern int decode_ftp(u_char *, int);
  19. extern int decode_telnet(u_char *, int);
  20. extern int decode_http(u_char *, int);
  21. extern int decode_ospf(u_char *, int);
  22. extern int decode_poppass(u_char *, int);
  23. extern int decode_pop(u_char *, int);
  24. extern int decode_nntp(u_char *, int);
  25. extern int decode_smb(u_char *, int);
  26. extern int decode_imap(u_char *, int);
  27. extern int decode_snmp(u_char *, int);
  28. extern int decode_ldap(u_char *, int);
  29. extern int decode_mmxp(u_char *, int);
  30. extern int decode_rlogin(u_char *, int);
  31. extern int decode_rip(u_char *, int);
  32. extern int decode_socks(u_char *, int);
  33. extern int decode_citrix(u_char *, int);
  34. extern int decode_oracle(u_char *, int);
  35. extern int decode_sniffer(u_char *, int);
  36. extern int decode_cvs(u_char *, int);
  37. extern int decode_icq(u_char *, int);
  38. extern int decode_napster(u_char *, int);
  39. extern int decode_aim(u_char *, int);
  40. extern int decode_postgresql(u_char *, int);
  41. extern int decode_pcanywhere(u_char *, int);
  42. extern int decode_x11(u_char *, int);
  43. extern int decode_irc(u_char *, int);
  44. extern int decode_portmap(u_char *, int);
  45. extern int decode_mountd(u_char *, int);
  46. extern int decode_yppasswd(u_char *, int);
  47.  
  48. static struct decode decodes[] = {
  49.     { "hex",    decode_hex },
  50.     { "ftp",    decode_ftp },
  51.     { "telnet",    decode_telnet },
  52.     { "http",    decode_http },
  53.     { "ospf",    decode_ospf },
  54.     { "poppass",    decode_poppass },
  55.     { "pop",    decode_pop },
  56.     { "nntp",    decode_nntp },
  57.     { "smb",    decode_smb },
  58.     { "imap",    decode_imap },
  59.     { "snmp",    decode_snmp },
  60.     { "ldap",    decode_ldap },
  61.     { "mmxp",    decode_mmxp },
  62.     { "rlogin",    decode_rlogin },
  63.     { "rip",    decode_rip },
  64.     { "socks",    decode_socks },
  65.     { "citrix",    decode_citrix },
  66.     { "oracle",    decode_oracle },
  67.     { "sniffer",    decode_sniffer },
  68.     { "cvs",    decode_cvs },
  69.     { "icq",    decode_icq },
  70.     { "napster",    decode_napster },
  71.     { "aim",    decode_aim },
  72.     { "postgresql",    decode_postgresql },
  73.     { "pcanywhere", decode_pcanywhere },
  74.     { "x11",    decode_x11 },
  75.     { "irc",    decode_irc },
  76.     { "portmap",    decode_portmap },
  77.     { "mountd",    decode_mountd },
  78.     { "yppasswd",    decode_yppasswd },
  79.     { NULL }
  80. };
  81.  
  82. u_char Buf[4096];
  83.  
  84. struct decode *
  85. getdecodebyname(const char *name)
  86. {
  87.     struct decode *dc;
  88.     
  89.     for (dc = decodes; dc->dc_name != NULL; dc++) {
  90.         if (strcasecmp(dc->dc_name, name) == 0)
  91.             return (dc);
  92.     }
  93.     return (NULL);
  94. }
  95.  
  96. /* Locate substring in a binary string. */
  97. u_char *
  98. bufbuf(u_char *big, int blen, u_char *little, int llen)
  99. {
  100.     u_char *p;
  101.     
  102.     for (p = big; p <= big + blen - llen; p++) {
  103.         if (memcmp(p, little, llen) == 0)
  104.             return (p);
  105.     }
  106.     return (NULL);
  107. }
  108.  
  109. /* Strip telnet options, as well as suboption data. */
  110. int
  111. strip_telopts(u_char *buf, int len)
  112. {
  113.     int i, j, subopt = 0;
  114.     char *p, *q;
  115.     
  116.     for (i = j = 0; i < len; i++) {
  117.         if (buf[i] == IAC) {
  118.             if (++i >= len) break;
  119.             else if (buf[i] > SB)
  120.                 i++;
  121.             else if (buf[i] == SB) {
  122.                 /* XXX - check for autologin username. */
  123.                 p = buf + i + 1;
  124.                 if ((q = bufbuf(p, len - i, "\xff", 1))
  125.                     != NULL) {
  126.                     if ((p = bufbuf(p, q - p, "USER\x01",
  127.                             5)) != NULL) {
  128.                         p += 5;
  129.                         buf[j++] = '[';
  130.                         memcpy(buf + j, p, q - p);
  131.                         j += q - p;
  132.                         buf[j++] = ']';
  133.                         buf[j++] = '\n';
  134.                     }
  135.                 }
  136.                 subopt = 1;
  137.             }
  138.             else if (buf[i] == SE) {
  139.                 if (!subopt) j = 0;
  140.                 subopt = 0;
  141.             }
  142.         }
  143.         else if (!subopt) {
  144.             /* XXX - convert isolated returns to newlines. */
  145.             if (buf[i] == '\r' && i + 1 < len &&
  146.                 buf[i + 1] != '\n')
  147.                 buf[j++] = '\n';
  148.             /* XXX - strip binary nulls. */
  149.             else if (buf[i] != '\0')
  150.                 buf[j++] = buf[i];
  151.         }
  152.     }
  153.     buf[j] = '\0';
  154.     
  155.     return (j);
  156. }
  157.  
  158. /* Strip a string buffer down to a maximum number of lines. */
  159. int
  160. strip_lines(char *buf, int max_lines)
  161. {
  162.     char *p;
  163.     int lines, nonascii;
  164.     
  165.     if (!buf) return (0);
  166.     
  167.     lines = nonascii = 0;
  168.     
  169.     for (p = buf; *p && lines < max_lines; p++) {
  170.         if (*p == '\n') lines++;
  171.         if (!isascii(*p)) nonascii++;
  172.     }
  173.     if (*p) *p = '\0';
  174.     
  175.     /* XXX - lame ciphertext heuristic */
  176.     if (nonascii * 3 > p - buf)
  177.         return (0);
  178.     
  179.     return (lines);
  180. }
  181.  
  182. int
  183. is_ascii_string(char *buf, int len)
  184. {
  185.     int i;
  186.     
  187.     for (i = 0; i < len; i++)
  188.         if (!isascii(buf[i])) return (0);
  189.     
  190.     return (1);
  191. }
  192.  
  193.